package com.mnb.common.utils;

import java.util.*;
import java.util.stream.Collectors;

public class MapKeyUtil {
    /**
     * 将List<Map<String, Object>>中的key转换为小写
     * @param list 原始数据列表
     * @return 转换后的新列表
     */
    public static List<Map<String, Object>> convertKeysToLowerCase(List<Map<String, Object>> list) {
        if (list == null || list.isEmpty()) {
            return new ArrayList<>();
        }

        return list.stream()
                .map(MapKeyUtil::convertMapKeysToLowerCase)
                .collect(Collectors.toList());
    }

    /**
     * 将单个Map的key转换为小写
     * @param map 原始Map
     * @return 转换后的新Map
     */
    public static Map<String, Object> convertMapKeysToLowerCase(Map<String, Object> map) {
        if (map == null || map.isEmpty()) {
            return new HashMap<>();
        }

        return map.entrySet().stream()
                .collect(HashMap::new,
                        (newMap, entry) -> newMap.put(entry.getKey().toLowerCase(), entry.getValue()),
                        HashMap::putAll);
    }

    /**
     * 将单个Map的key转换为小写（保持原Map的类型）
     * @param map 原始Map
     * @return 转换后的新Map
     */
    public static Map<String, Object> convertMapKeysToLowerCasePreserveType(Map<String, Object> map) {
        if (map == null || map.isEmpty()) {
            return map instanceof LinkedHashMap ? new LinkedHashMap<>() : new HashMap<>();
        }

        Map<String, Object> resultMap = map instanceof LinkedHashMap ?
                new LinkedHashMap<>(map.size()) : new HashMap<>(map.size());

        map.forEach((key, value) -> resultMap.put(key.toLowerCase(), value));
        return resultMap;
    }

    /**
     * 将嵌套的Map结构中的所有key转换为小写
     * @param list 原始数据列表
     * @return 转换后的新列表
     */
    @SuppressWarnings("unchecked")
    public static List<Map<String, Object>> convertNestedKeysToLowerCase(List<Map<String, Object>> list) {
        if (list == null || list.isEmpty()) {
            return new ArrayList<>();
        }

        return list.stream()
                .map(map -> {
                    Map<String, Object> newMap = new HashMap<>();
                    map.forEach((key, value) -> {
                        String lowercaseKey = key.toLowerCase();
                        if (value instanceof Map) {
                            newMap.put(lowercaseKey, convertMapKeysToLowerCase((Map<String, Object>) value));
                        } else if (value instanceof List) {
                            newMap.put(lowercaseKey, handleListValue((List<?>) value));
                        } else {
                            newMap.put(lowercaseKey, value);
                        }
                    });
                    return newMap;
                })
                .collect(Collectors.toList());
    }

    /**
     * 处理List类型的值
     * @param list 原始List
     * @return 处理后的List
     */
    @SuppressWarnings("unchecked")
    private static List<?> handleListValue(List<?> list) {
        return list.stream()
                .map(item -> {
                    if (item instanceof Map) {
                        return convertMapKeysToLowerCase((Map<String, Object>) item);
                    } else if (item instanceof List) {
                        return handleListValue((List<?>) item);
                    }
                    return item;
                })
                .collect(Collectors.toList());
    }
}
